import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;
import java.util.StringJoiner;



/**
 * 
 * 流浪地球
 * 
 * 题目描述

流浪地球计划在赤道上均匀部署了 N 个转向发动机，按位置顺序编号为 0 ~ N

初始状态下所有的发动机都是未启动状态
发动机启动的方式分为“手动启动”和“关联启动”两种方式
如果在时刻 1 一个发动机被启动，下一个时刻 2 与之相邻的两个发动机就会被“关联启动”
如果准备启动某个发动机时，它已经被启动了，则什么都不用做
发动机 0 与发动机 N-1 是相邻的
地球联合政府准备挑选某些发动机在某些时刻进行“手动启动”。当然最终所有的发动机都会被启动。哪些发动机最晚被启动呢？
 */

/**
 * 输入描述
第一行两个数字 N 和 E，中间有空格

N 代表部署发动机的总个数，1 < N ≤ 1000
E 代表计划手动启动的发动机总个数，1 ≤ E ≤ 1000，E ≤ N
接下来共 E 行，每行都是两个数字 T 和 P，中间有空格

T 代表发动机的手动启动时刻，0 ≤ T ≤ N
P 代表次发动机的位置编号，0 ≤ P < N
 */

/**
 * 输出描述
第一行一个数字 N， 以回车结束

N 代表最后被启动的发动机个数
第二行 N 个数字，中间有空格，以回车结束

每个数字代表发动机的位置编号，从小到大排序
 */


/**
 * 
 * 用例
 * 
 * 输入   8 2
 *       0 6
 *       0 2
 * 输出   2
 *       0 4
 * 
 * 说明
 * 8个发动机；
时刻0启动（2,6）;
时刻1启动（1,3,5,7）（其中1,3被2关联启动，5,7被6关联启动）；
时刻2启动（0,4）（其中0被1,7关联启动，4被3,5关联启动）；
至此所有发动机都被启动，最后被启动的有2个，分别是0和4。

8 1
0 5
时刻0启动（5）
时刻1启动（4, 6）
时刻2启动（3, 7）
时刻3启动（2, 0）
时刻4启动（1）
 */

/**
 * 
 * 问题解析
 * 
 * 发动机 0 与发动机 N-1 是相邻的，即形成一个环
 * 
 * 
 */

 /**
  * 
  1、控制台输入  Scanner scanner = new Scanner(System.in);
  2、获取输入方式   int n = scanner.nextInt();
  3、StringJoiner 字符串拼接  按照“ ” 拼接
  4、list 流处理  list.stream 转化成流  .sorted 根据规则排序 sorted((a, b) -> a - b)  按照 a < b 排序
  forEach  list 遍历  joiner.add(p+"")  == p+“ ”

  */


public class 流浪地球 {

    public static void main(String[] args){

        try{

            //接收输入
        Scanner scanner = new Scanner(System.in);

        //发动机总数
        int n = scanner.nextInt();
        //计划收到启动发动机总数
        int e = scanner.nextInt();

        //记录每个发动机启动最终启动时刻
        int[] launches = new int[n];

        //先用 10001 填充 数组
        Arrays.fill(launches, 1001);

        //接收启动参数  e 表示开始手动启动次数
        for(int i=0; i<e; i++){

            //发动机手动启动时间
            int t = scanner.nextInt();
            //发动机的位置编号
            int p = scanner.nextInt();

            //设置编号 p 发动机的启动时间
            launches[p] = t;
        }

        //从编号i 的发动机启动后，关联启动的发动机编号
        for(int i=0; i<n; i++){

            for(int j=0; j<n; j++){

                //这里需要理解内联和外联，
                //因为发动机是一个圆环，内联可以看作顺时针i 到 j 的发动机差距
                //外联可以看作逆时针 k 到 j 的发动机差距
                //这里需要取到发动机差值的最小值

                //内联差距
                int innerDis = Math.abs(i - j);
                //外联差距
                int outerDis = n - innerDis;
                //最短关联距离
                int minDis = Math.min(innerDis, outerDis);

                launches[j] = Math.min(launches[j], launches[i]+minDis);


            }
        }


        //最晚启动时间
        int maxT = 0;
        //最晚启动发动机编号集合
        List<Integer> last = new ArrayList<Integer>();

        for(int p=0; p<launches.length; p++){

            //当前发动机启动时刻
            int t = launches[p];

            //不是更晚启动，
            if(t < maxT) continue;
            
            if(t > maxT){

                maxT = t;
                last.clear();
                
            }

            last.add(p);

        }

        StringJoiner joiner = new StringJoiner(" ");
        last.stream().sorted((a, b) -> a - b).forEach(p -> joiner.add(p+""));

        System.out.println(last.size());
        System.out.println(joiner);

        }catch(Exception e){
            e.printStackTrace();
            System.out.println("程序执行异常--"+(null==e?"":e.getMessage())
            );
        }

    }
}
